Tovushni jilovlash: Python yordamida audio sintez va raqamli signallarga ishlov berish bo'yicha chuqur qo'llanma

Quloqchinlaringizdagi musiqa oqimidan tortib, video o'yinlarning qamrab oluvchi ovoz manzaralari va qurilmalarimizdagi ovozli yordamchilargacha, raqamli audio zamonaviy hayotning ajralmas qismidir. Ammo bu tovushlar qanday yaratilishi haqida hech o'ylab ko'rganmisiz? Bu sehr emas; bu matematika, fizika va informatikaning ajoyib uyg'unligi bo'lib, Raqamli Signallarga Ishlov Berish (DSP) deb nomlanadi. Bugun biz parda ortiga nazar tashlab, Python kuchidan foydalanib, tovushni noldan yaratish, o'zgartirish va sintez qilishni ko'rsatamiz.

Ushbu qoʻllanma dasturchilar, maʼlumotlar boʻyicha mutaxassislar, musiqachilar, rassomlar hamda kod va ijodkorlik kesishuviga qiziquvchi barcha uchun moʻljallangan. DSP mutaxassisi yoki tajribali ovoz muhandisi bo'lishingiz shart emas. Python bo'yicha asosiy tushunchalar bilan siz tez orada o'zingizning noyob ovoz manzaralaringizni yarata boshlaysiz. Biz raqamli audioning asosiy qurilish bloklarini o'rganamiz, klassik to'lqin shakllarini yaratamiz, ularni qobiqlar va filtrlar bilan shakllantiramiz va hatto mini-sintezator yaratamiz. Keling, hisoblash audiosining yorqin dunyosiga sayohatimizni boshlaymiz.

Raqamli Audioning Asosiy Elementlarini Tushunish

Bir qator kod yozishdan oldin, biz tovush kompyuterda qanday tasvirlanishini tushunishimiz kerak. Jismoniy dunyoda tovush uzluksiz, analog bosim to'lqinidir. Kompyuterlar raqamli bo'lgani uchun uzluksiz to'lqinni saqlay olmaydi. Buning o'rniga, ular har soniyada to'lqinning minglab lahzali suratlari yoki namunalarini (samples) oladi. Bu jarayon diskretlash (sampling) deb ataladi.

Diskretlash Chastotasi (Sample Rate)

Diskretlash chastotasi bir soniyada qancha namuna olinishini belgilaydi. U Gerts (Hz) bilan o'lchanadi. Yuqori diskretlash chastotasi asl tovush to'lqinining aniqroq tasvirini beradi, bu esa yuqori sifatli audioga olib keladi. Keng tarqalgan diskretlash chastotalari quyidagilardir:

• 44100 Hz (44.1 kHz): Audio CDlar uchun standart. U Naykvist-Shennon diskretlash teoremasiga asoslanib tanlangan bo'lib, unga ko'ra diskretlash chastotasi siz yozib olmoqchi bo'lgan eng yuqori chastotadan kamida ikki baravar yuqori bo'lishi kerak. Inson eshitish diapazoni taxminan 20,000 Hz bilan cheklanganligi sababli, 44.1 kHz yetarli zaxirani ta'minlaydi.
• 48000 Hz (48 kHz): Professional video va raqamli audio ish stansiyalari (DAW) uchun standart.
• 96000 Hz (96 kHz): Yanada yuqori aniqlik uchun yuqori sifatli audio ishlab chiqarishda qo'llaniladi.

Biz o'z maqsadlarimiz uchun asosan 44100 Hz dan foydalanamiz, chunki u sifat va hisoblash samaradorligi o'rtasida a'lo darajadagi muvozanatni ta'minlaydi.

Bit Chuqurligi (Bit Depth)

Agar diskretlash chastotasi vaqt bo'yicha aniqlikni belgilasa, Bit Chuqurligi amplituda (ovoz balandligi) bo'yicha aniqlikni belgilaydi. Har bir namuna o'sha lahzadagi to'lqin amplitudasini ifodalovchi sondir. Bit chuqurligi - bu sonni saqlash uchun ishlatiladigan bitlar soni. Yuqori bit chuqurligi ko'proq mumkin bo'lgan amplituda qiymatlariga imkon beradi, bu esa kattaroq dinamik diapazonga (eng past va eng baland tovushlar orasidagi farq) va pastroq shovqin darajasiga olib keladi.

• 16-bit: CDlar uchun standart, 65,536 ta mumkin bo'lgan amplituda darajasini taklif qiladi.
• 24-bit: Professional audio ishlab chiqarish uchun standart, 16.7 milliondan ortiq darajani taklif qiladi.

Biz NumPy kabi kutubxonalar yordamida Pythonda audio yaratganimizda, odatda maksimal aniqlik uchun suzuvchi nuqtali sonlar bilan ishlaymiz (masalan, -1.0 va 1.0 oralig'ida). Keyin ular faylga saqlash yoki uskuna orqali ijro etish paytida ma'lum bir bit chuqurligiga (masalan, 16-bitli butun sonlarga) o'zgartiriladi.

Kanallar

Bu shunchaki audio oqimlari sonini anglatadi. Mono audio bitta kanalga ega, Stereo audio esa ikkita (chap va o'ng) kanalga ega bo'lib, fazo va yo'nalish hissini yaratadi.

Python Muhitingizni Sozlash

Boshlash uchun bizga bir nechta muhim Python kutubxonalari kerak bo'ladi. Ular bizning sonli hisoblash, signalga ishlov berish, vizualizatsiya va audio ijro etish uchun asboblar to'plamimizni tashkil qiladi.

Siz ularni pip yordamida o'rnatishingiz mumkin:

pip install numpy scipy matplotlib sounddevice

Keling, ularning vazifalarini qisqacha ko'rib chiqaylik:

• NumPy: Pythondagi ilmiy hisoblashlarning asosidir. Biz undan audio signallarimizni ifodalovchi sonlar massivlarini yaratish va o'zgartirish uchun foydalanamiz.
• SciPy: NumPy ustiga qurilgan bo'lib, u signalga ishlov berish, jumladan, to'lqin shakllarini yaratish va filtrlash uchun keng algoritmlar to'plamini taqdim etadi.
• Matplotlib: Pythondagi asosiy grafik chizish kutubxonasi. U to'lqin shakllarimizni vizualizatsiya qilish va ishlov berish effektlarini tushunish uchun bebahodir.
• SoundDevice: NumPy massivlarimizni kompyuteringizning dinamiklari orqali audio sifatida ijro etish uchun qulay kutubxona. U oddiy va kross-platformali interfeysni ta'minlaydi.

To'lqin Shakllarini Yaratish: Sintezning Yuragi

Qanchalik murakkab bo'lmasin, barcha tovushlarni oddiy, fundamental to'lqin shakllarining kombinatsiyalariga bo'lish mumkin. Bular bizning tovush palitramizdagi asosiy ranglardir. Keling, ularni qanday yaratishni o'rganamiz.

Sinus To'lqini: Eng Sof Ohang

Sinus to'lqini barcha tovushlarning mutlaq qurilish blokidir. U obertonlar yoki garmonikalarsiz yagona chastotani ifodalaydi. U juda silliq, toza eshitiladi va ko'pincha 'fleytaga o'xshash' deb ta'riflanadi. Matematik formula quyidagicha:

y(t) = Amplituda * sin(2 * π * chastota * t)

Bu yerda 't' vaqtni bildiradi. Keling, buni Python kodiga o'giramiz.

            
import numpy as np
import sounddevice as sd
import matplotlib.pyplot as plt

# --- Global Parametrlar ---
SAMPLE_RATE = 44100  # soniyadagi namunalar soni
DURATION = 3.0       # soniya

# --- To'lqin shaklini yaratish ---
def generate_sine_wave(frequency, duration, sample_rate, amplitude=0.5):
    """Sinus to'lqinini yaratish.

    Args:
        frequency (float): Sinus to'lqinining Gts (Hz) dagi chastotasi.
        duration (float): To'lqinning soniyadagi davomiyligi.
        sample_rate (int): Diskretlash chastotasi Gts (Hz) da.
        amplitude (float): To'lqin amplitudasi (0.0 dan 1.0 gacha).

    Returns:
        np.ndarray: Yaratilgan sinus to'lqini NumPy massivi sifatida.
    """
    # Vaqt nuqtalari massivini yaratish
    t = np.linspace(0, duration, int(sample_rate * duration), False)

    # Sinus to'lqinini yaratish
    # 2 * pi * chastota - bu burchak chastotasi
    wave = amplitude * np.sin(2 * np.pi * frequency * t)
    return wave

# --- Foydalanish Misoli ---
if __name__ == "__main__":
    # 440 Gts (A4 notasi) sinus to'lqinini yaratish
    frequency_a4 = 440.0
    sine_wave = generate_sine_wave(frequency_a4, DURATION, SAMPLE_RATE)

    print("440 Gts sinus to'lqini ijro etilmoqda...")
    # Ovozni ijro etish
    sd.play(sine_wave, SAMPLE_RATE)
    sd.wait() # Ovoz ijrosi tugashini kutish
    print("Ijro tugadi.")

    # --- Vizualizatsiya ---
    # To'lqin shaklini ko'rish uchun uning kichik bir qismini chizish
    plt.figure(figsize=(12, 4))
    plt.plot(sine_wave[:500])
    plt.title("Sinus to'lqini (440 Gts)")
    plt.xlabel("Namuna")
    plt.ylabel("Amplituda")
    plt.grid(True)
    plt.show()

            

              
                Copy
              
            
          

Bu kodda np.linspace vaqt o'qini ifodalovchi massiv yaratadi. So'ngra biz bu vaqt massiviga kerakli chastota bilan masshtablangan sinus funksiyasini qo'llaymiz. Natija - har bir elementi bizning tovush to'lqinimizning namunasi bo'lgan NumPy massivi. Keyin biz uni sounddevice yordamida ijro etishimiz va matplotlib yordamida vizualizatsiya qilishimiz mumkin.

Boshqa Asosiy To'lqin Shakllarini O'rganish

Sinus to'lqini sof bo'lsa-da, u har doim ham eng qiziqarlisi emas. Boshqa asosiy to'lqin shakllari garmonikalarga boy bo'lib, ularga murakkabroq va yorqinroq xarakter (tembr) beradi. scipy.signal moduli ularni yaratish uchun qulay funksiyalarni taqdim etadi.

To'rtburchak To'lqin

To'rtburchak to'lqin bir zumda maksimal va minimal amplitudalari o'rtasida sakraydi. U faqat toq raqamli garmonikalarni o'z ichiga oladi. U yorqin, jarangdor va biroz 'bo'sh' yoki 'raqamli' tovushga ega bo'lib, ko'pincha dastlabki video o'yin musiqasi bilan bog'lanadi.

            
from scipy import signal

# To'rtburchak to'lqin yaratish
square_wave = 0.5 * signal.square(2 * np.pi * 440 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False))
# sd.play(square_wave, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

Arrasimon To'lqin

Arrasimon to'lqin chiziqli ravishda ko'tarilib, so'ngra bir zumda minimal qiymatiga tushadi (yoki aksincha). U barcha butun sonli garmonikalarni (ham juft, ham toq) o'z ichiga olganligi sababli nihoyatda boy. Bu uni juda yorqin, g'uvillovchi tovushga aylantiradi va keyinroq ko'rib chiqadigan subtraktiv sintez uchun ajoyib boshlang'ich nuqtadir.

            
# Arrasimon to'lqin yaratish
sawtooth_wave = 0.5 * signal.sawtooth(2 * np.pi * 440 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False))
# sd.play(sawtooth_wave, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

Uchburchak To'lqin

Uchburchak to'lqin chiziqli ravishda ko'tariladi va tushadi. To'rtburchak to'lqin kabi, u faqat toq garmonikalarni o'z ichiga oladi, ammo ularning amplitudasi ancha tezroq pasayadi. Bu unga to'rtburchak to'lqindan yumshoqroq va mayinroq, sinus to'lqiniga yaqinroq, lekin biroz ko'proq 'mazmun'ga ega tovush beradi.

            
# Uchburchak to'lqin yaratish (kengligi 0.5 bo'lgan arrasimon to'lqin)
triangle_wave = 0.5 * signal.sawtooth(2 * np.pi * 440 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False), width=0.5)
# sd.play(triangle_wave, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

Oq Shovqin: Tasodifiylik Ovozi

Oq shovqin har bir chastotada teng energiyaga ega bo'lgan signaldir. U statik yoki sharsharaning 'shhhh' tovushiga o'xshaydi. U tovush dizaynida zarbli tovushlarni (masalan, hay-xet va barabanlar) va atmosfera effektlarini yaratish uchun nihoyatda foydalidir. Uni yaratish juda oddiy.

            
# Oq shovqin yaratish
num_samples = int(SAMPLE_RATE * DURATION)
white_noise = np.random.uniform(-1, 1, num_samples)
# sd.play(white_noise, SAMPLE_RATE)
# sd.wait()

            

              
                Copy
              
            
          

Additiv Sintez: Murakkablikni Yaratish

Fransuz matematigi Jozef Furye har qanday murakkab, davriy to'lqin shaklini oddiy sinus to'lqinlarining yig'indisiga ajratish mumkinligini kashf etdi. Bu additiv sintezning asosidir. Turli chastotalar (garmonikalar) va amplitudalardagi sinus to'lqinlarini qo'shish orqali biz yangi, boyroq tembrlar yaratishimiz mumkin.

Keling, fundamental chastotaning birinchi bir necha garmonikasini qo'shib, murakkabroq ohang yarataylik.

            
def generate_complex_tone(fundamental_freq, duration, sample_rate):
    t = np.linspace(0, duration, int(sample_rate * duration), False)
    
    # Asosiy chastotadan boshlaymiz
    tone = 0.5 * np.sin(2 * np.pi * fundamental_freq * t)
    
    # Garmonikalarni (obertonlarni) qo'shamiz
    # 2-garmonika (bir oktava yuqori), pastroq amplituda
    tone += 0.25 * np.sin(2 * np.pi * (2 * fundamental_freq) * t)
    # 3-garmonika, yanada pastroq amplituda
    tone += 0.12 * np.sin(2 * np.pi * (3 * fundamental_freq) * t)
    # 5-garmonika
    tone += 0.08 * np.sin(2 * np.pi * (5 * fundamental_freq) * t)
    
    # To'lqin shaklini -1 va 1 oralig'ida bo'lishi uchun normallashtirish
    tone = tone / np.max(np.abs(tone))
    return tone

# --- Foydalanish Misoli ---
complex_tone = generate_complex_tone(220, DURATION, SAMPLE_RATE)
sd.play(complex_tone, SAMPLE_RATE)
sd.wait()

            

              
                Copy
              
            
          

Qaysi garmonikalarni va qanday amplitudalarda qo'shishni diqqat bilan tanlab, siz haqiqiy dunyo asboblarining tovushlariga taqlid qilishni boshlashingiz mumkin. Bu oddiy misol allaqachon oddiy sinus to'lqinidan ancha boyroq va qiziqarliroq eshitiladi.

Ovozni Qobiqlar Bilan Shakllantirish (ADSR)

Hozirgacha bizning tovushlarimiz keskin boshlanib, keskin to'xtaydi. Ularning davomiyligi bo'ylab doimiy ovoz balandligi bor, bu juda g'ayritabiiy va robotga o'xshash eshitiladi. Haqiqiy dunyoda tovushlar vaqt o'tishi bilan o'zgaradi. Pianino notasining keskin, baland boshlanishi tezda pasayadi, skripkada chalingan nota esa asta-sekin balandlashishi mumkin. Biz bu dinamik o'zgarishni amplituda qobig'i yordamida boshqaramiz.

ADSR Modeli

Eng keng tarqalgan qobiq turi ADSR qobig'i bo'lib, u to'rt bosqichdan iborat:

• Attack (Hujum): Ovozning jimlikdan maksimal amplitudaga yetishi uchun ketadigan vaqt. Tez hujum zarbli, keskin tovush (baraban zarbasi kabi) yaratadi. Sekin hujum esa mayin, shishib boruvchi tovush (torli pad kabi) yaratadi.
• Decay (Pasayish): Ovozning maksimal hujum darajasidan barqaror darajagacha (sustain) pasayishi uchun ketadigan vaqt.
• Sustain (Barqarorlik): Nota ushlab turilganda ovoz saqlaydigan amplituda darajasi. Bu vaqt emas, balki darajadir.
• Release (Qo'yib yuborish): Nota qo'yib yuborilgandan so'ng ovozning barqaror darajadan jimlikkacha so'nishi uchun ketadigan vaqt. Uzoq 'release' tovushning uzoqroq saqlanib qolishiga olib keladi, masalan, sustain pedali bosilgan pianino notasi kabi.

Pythonda ADSR Qobig'ini Amalga Oshirish

Biz ADSR qobig'ini NumPy massivi sifatida yaratish uchun funksiya yozishimiz mumkin. So'ngra uni oddiy elementma-element ko'paytirish orqali to'lqin shaklimizga qo'llaymiz.

            
def adsr_envelope(duration, sample_rate, attack_time, decay_time, sustain_level, release_time):
    num_samples = int(duration * sample_rate)
    attack_samples = int(attack_time * sample_rate)
    decay_samples = int(decay_time * sample_rate)
    release_samples = int(release_time * sample_rate)
    sustain_samples = num_samples - attack_samples - decay_samples - release_samples

    if sustain_samples < 0:
        # Agar vaqtlar juda uzun bo'lsa, ularni proportsional ravishda moslashtiramiz
        total_time = attack_time + decay_time + release_time
        attack_time, decay_time, release_time = \
            attack_time/total_time*duration, decay_time/total_time*duration, release_time/total_time*duration
        attack_samples = int(attack_time * sample_rate)
        decay_samples = int(decay_time * sample_rate)
        release_samples = int(release_time * sample_rate)
        sustain_samples = num_samples - attack_samples - decay_samples - release_samples

    # Qobiqning har bir qismini yaratish
    attack = np.linspace(0, 1, attack_samples)
    decay = np.linspace(1, sustain_level, decay_samples)
    sustain = np.full(sustain_samples, sustain_level)
    release = np.linspace(sustain_level, 0, release_samples)

    return np.concatenate([attack, decay, sustain, release])

# --- Foydalanish Misoli: Chertma va Pad tovushi ---

# Chertma tovushi (tez hujum, tez pasayish, barqarorlik yo'q)
pluck_envelope = adsr_envelope(DURATION, SAMPLE_RATE, 0.01, 0.2, 0.0, 0.5)

# Pad tovushi (sekin hujum, uzoq 'release')
pad_envelope = adsr_envelope(DURATION, SAMPLE_RATE, 0.5, 0.2, 0.7, 1.0)

# Qobiqlarni qo'llash uchun garmoniklarga boy arrasimon to'lqin yaratish
saw_wave_for_env = generate_complex_tone(220, DURATION, SAMPLE_RATE)

# Qobiqlarni qo'llash
plucky_sound = saw_wave_for_env * pluck_envelope
pad_sound = saw_wave_for_env * pad_envelope

print("Chertma tovush ijro etilmoqda...")
sd.play(plucky_sound, SAMPLE_RATE)
sd.wait()

print("Pad tovushi ijro etilmoqda...")
sd.play(pad_sound, SAMPLE_RATE)
sd.wait()

# Qobiqlarni vizualizatsiya qilish
plt.figure(figsize=(12, 6))
plt.subplot(2, 1, 1)
plt.plot(pluck_envelope)
plt.title("Chertma ADSR Qobig'i")
plt.subplot(2, 1, 2)
plt.plot(pad_envelope)
plt.title("Pad ADSR Qobig'i")
plt.tight_layout()
plt.show()

            

              
                Copy
              
            
          

E'tibor bering, bir xil asosiy to'lqin shakli faqatgina boshqa qobiqni qo'llash orqali o'z xarakterini qanchalik keskin o'zgartiradi. Bu tovush dizaynidagi asosiy texnikadir.

Raqamli Filtrlashga Kirish (Subtraktiv Sintez)

Additiv sintez sinus to'lqinlarini qo'shish orqali tovush yaratsa, subtraktiv sintez aksincha ishlaydi. Biz garmoniklarga boy signal bilan boshlaymiz (arrasimon to'lqin yoki oq shovqin kabi) va keyin filtrlar yordamida ma'lum chastotalarni kesib tashlaymiz yoki pasaytiramiz. Bu haykaltaroshning marmar bo'lagi bilan boshlab, shaklni ochish uchun uni o'yib tashlashiga o'xshaydi.

Asosiy Filtr Turlari

• Past chastotali filtr (Low-Pass): Bu sintezdagi eng keng tarqalgan filtr. U ma'lum bir 'kesish' nuqtasidan pastdagi chastotalarning o'tishiga ruxsat beradi va undan yuqoridagi chastotalarni pasaytiradi. Bu tovushni qorong'iroq, iliqroq yoki bo'g'iqroq qiladi.
• Yuqori chastotali filtr (High-Pass): Past chastotali filtrning aksi. U kesish nuqtasidan yuqoridagi chastotalarning o'tishiga ruxsat berib, bas va past chastotalarni olib tashlaydi. Bu tovushni ingichkaroq yoki jarangdorroq qiladi.
• Polosali filtr (Band-Pass): Faqat ma'lum bir chastotalar diapazonining o'tishiga ruxsat berib, ham yuqori, ham past chastotalarni kesadi. Bu 'telefon' yoki 'radio' effektini yaratishi mumkin.
• To'xtatuvchi polosali (Notch) filtr (Band-Stop): Polosali filtrning aksi. U ma'lum bir chastotalar diapazonini olib tashlaydi.

SciPy yordamida Filtrlarni Amalga Oshirish

scipy.signal kutubxonasi raqamli filtrlarni loyihalash va qo'llash uchun kuchli vositalarni taqdim etadi. Biz Battervort filtri deb nomlanuvchi keng tarqalgan turdan foydalanamiz, u o'tkazish polosasidagi tekis javobi bilan mashhur.

Jarayon ikki bosqichdan iborat: birinchidan, filtr koeffitsientlarini olish uchun uni loyihalash, ikkinchidan, o'sha koeffitsientlarni audio signalimizga qo'llash.

            
from scipy.signal import butter, lfilter, freqz

def butter_lowpass_filter(data, cutoff, fs, order=5):
    """Signalga past chastotali Battervort filtrini qo'llash."""
    nyquist = 0.5 * fs
    normal_cutoff = cutoff / nyquist
    # Filtr koeffitsientlarini olish
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    y = lfilter(b, a, data)
    return y

# --- Foydalanish Misoli ---
# Boy signal bilan boshlaymiz: arrasimon to'lqin
saw_wave_rich = 0.5 * signal.sawtooth(2 * np.pi * 220 * np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False))

print("Asl arrasimon to'lqin ijro etilmoqda...")
sd.play(saw_wave_rich, SAMPLE_RATE)
sd.wait()

# Kesish chastotasi 800 Gts bo'lgan past chastotali filtrni qo'llash
filtered_saw = butter_lowpass_filter(saw_wave_rich, cutoff=800, fs=SAMPLE_RATE, order=6)

print("Filtrlangan arrasimon to'lqin ijro etilmoqda...")
sd.play(filtered_saw, SAMPLE_RATE)
sd.wait()

# --- Filtrning chastota javobini vizualizatsiya qilish ---
cutoff_freq = 800
order = 6
b, a = butter(order, cutoff_freq / (0.5 * SAMPLE_RATE), btype='low')
w, h = freqz(b, a, worN=8000)

plt.figure(figsize=(10, 5))
plt.plot(0.5 * SAMPLE_RATE * w / np.pi, np.abs(h), 'b')
plt.plot(cutoff_freq, 0.5 * np.sqrt(2), 'ko')
plt.axvline(cutoff_freq, color='k', linestyle='--')
plt.xlim(0, 5000)
plt.title("Past chastotali filtrning chastota javobi")
plt.xlabel('Chastota [Gts]')
plt.grid()
plt.show()

            

              
                Copy
              
            
          

Asl va filtrlangan to'lqinlar orasidagi farqni tinglang. Asli yorqin va g'uvillovchi; filtrlangan versiyasi esa ancha yumshoqroq va qorong'iroq, chunki yuqori chastotali garmonikalar olib tashlangan. Past chastotali filtrning kesish chastotasini o'zgartirish elektron musiqadagi eng ifodali va keng tarqalgan usullardan biridir.

Modulyatsiya: Harakat va Hayot Qo'shish

Statik tovushlar zerikarli. Modulyatsiya dinamik, rivojlanuvchi va qiziqarli tovushlar yaratishning kalitidir. Printsip oddiy: bir signal (modulyator) yordamida boshqa signalning (tashuvchi) parametrini boshqarish. Keng tarqalgan modulyator Past Chastotali Ossillyator (LFO) bo'lib, u inson eshitish diapazonidan past chastotali (masalan, 0.1 Gts dan 20 Gts gacha) ossillyatordir.

Amplituda Modulyatsiyasi (AM) va Tremolo

Bu biz LFO yordamida tovushimizning amplitudasini boshqarganimizda yuz beradi. Natijada ovoz balandligida ritmik pulsatsiya, ya'ni tremolo paydo bo'ladi.

            
# Tashuvchi to'lqin (biz eshitadigan tovush)
carrier_freq = 300
carrier = generate_sine_wave(carrier_freq, DURATION, SAMPLE_RATE)

# Modulyator LFO (ovoz balandligini boshqaradi)
lfo_freq = 5 # 5 Gts LFO
modulator = generate_sine_wave(lfo_freq, DURATION, SAMPLE_RATE, amplitude=1.0)

# Tremolo effektini yaratish
# Modulyatorni 0 dan 1 gacha masshtablaymiz
tremolo_modulator = (modulator + 1) / 2

tremolo_sound = carrier * tremolo_modulator

print("Tremolo effekti ijro etilmoqda...")
sd.play(tremolo_sound, SAMPLE_RATE)
sd.wait()

            

              
                Copy
              
            
          

Chastota Modulyatsiyasi (FM) va Vibrato

Bu biz LFO yordamida tovushimizning chastotasini boshqarganimizda yuz beradi. Chastotaning sekin, nozik modulyatsiyasi vibrato yaratadi - bu xonandalar va skripkachilar ifodadorlik qo'shish uchun ishlatadigan ohangning mayin tebranishidir.

            
# Vibrato effektini yaratish
t = np.linspace(0, DURATION, int(SAMPLE_RATE * DURATION), False)

carrier_freq = 300
lfo_freq = 7
modulation_depth = 10 # Chastota qanchalik o'zgarishi

# LFO tashuvchi chastotaga qo'shiladi
modulator_vibrato = modulation_depth * np.sin(2 * np.pi * lfo_freq * t)

# Oniy chastota vaqt o'tishi bilan o'zgaradi
instantaneous_freq = carrier_freq + modulator_vibrato

# Fazani olish uchun chastotani integrallashimiz kerak
phase = np.cumsum(2 * np.pi * instantaneous_freq / SAMPLE_RATE)

vibrato_sound = 0.5 * np.sin(phase)

print("Vibrato effekti ijro etilmoqda...")
sd.play(vibrato_sound, SAMPLE_RATE)
sd.wait()

            

              
                Copy
              
            
          

Bu FM sintezining soddalashtirilgan versiyasidir. LFO chastotasi eshitiladigan diapazonga ko'tarilganda, u murakkab yon polosali chastotalarni yaratadi, natijada boy, qo'ng'iroqqa o'xshash va metallik ohanglar paydo bo'ladi. Bu Yamaha DX7 kabi sintezatorlarning mashhur tovushining asosidir.

Hammasini Birlashtirish: Mini Sintezator Loyihasi

Keling, o'rganganlarimizning barchasini oddiy, funksional sintezator sinfiga birlashtiraylik. Bu bizning ossillyator, qobiq va filtrlarimizni bitta, qayta foydalanish mumkin bo'lgan ob'ektga jamlaydi.

            
class MiniSynth:
    def __init__(self, sample_rate=44100):
        self.sample_rate = sample_rate

    def generate_note(self, frequency, duration, waveform='sine', 
                      adsr_params=(0.05, 0.2, 0.5, 0.3), 
                      filter_params=None):
        """Yagona sintezlangan nota yaratish."""
        num_samples = int(duration * self.sample_rate)
        t = np.linspace(0, duration, num_samples, False)

        # 1. Ossillyator
        if waveform == 'sine':
            wave = np.sin(2 * np.pi * frequency * t)
        elif waveform == 'square':
            wave = signal.square(2 * np.pi * frequency * t)
        elif waveform == 'sawtooth':
            wave = signal.sawtooth(2 * np.pi * frequency * t)
        elif waveform == 'triangle':
            wave = signal.sawtooth(2 * np.pi * frequency * t, width=0.5)
        else:
            raise ValueError("Qo'llab-quvvatlanmaydigan to'lqin shakli")

        # 2. Qobiq
        attack, decay, sustain, release = adsr_params
        envelope = adsr_envelope(duration, self.sample_rate, attack, decay, sustain, release)
        # Qobiq va to'lqin uzunligi bir xil ekanligiga ishonch hosil qilish
        min_len = min(len(wave), len(envelope))
        wave = wave[:min_len] * envelope[:min_len]

        # 3. Filtr (ixtiyoriy)
        if filter_params:
            cutoff = filter_params.get('cutoff', 1000)
            order = filter_params.get('order', 5)
            filter_type = filter_params.get('type', 'low')
            
            if filter_type == 'low':
                wave = butter_lowpass_filter(wave, cutoff, self.sample_rate, order)
            # ... bu yerga yuqori chastotali va hokazolarni qo'shish mumkin

        # Amplitudani 0.5 ga normallashtirish
        return wave * 0.5

# --- Sintezatordan Foydalanish Misoli ---

synth = MiniSynth()

# Yorqin, chertmali bas tovushi
bass_note = synth.generate_note(
    frequency=110, # A2 notasi
    duration=1.5,
    waveform='sawtooth',
    adsr_params=(0.01, 0.3, 0.0, 0.2),
    filter_params={'cutoff': 600, 'order': 6}
)

print("Sintezator bas notasi ijro etilmoqda...")
sd.play(bass_note, SAMPLE_RATE)
sd.wait()

# Yumshoq, atmosfera pad tovushi
pad_note = synth.generate_note(
    frequency=440, # A4 notasi
    duration=5.0,
    waveform='triangle',
    adsr_params=(1.0, 0.5, 0.7, 1.5)
)

print("Sintezator pad notasi ijro etilmoqda...")
sd.play(pad_note, SAMPLE_RATE)
sd.wait()

# Oddiy kuy
melody = [
    ('C4', 261.63, 0.4),
    ('D4', 293.66, 0.4),
    ('E4', 329.63, 0.4),
    ('C4', 261.63, 0.8)
]

final_melody = []
for note, freq, dur in melody:
    sound = synth.generate_note(freq, dur, 'square', adsr_params=(0.01, 0.1, 0.2, 0.1), filter_params={'cutoff': 1500})
    final_melody.append(sound)

full_melody_wave = np.concatenate(final_melody)

print("Qisqa kuy ijro etilmoqda...")
sd.play(full_melody_wave, SAMPLE_RATE)
sd.wait()


            

              
                Copy
              
            
          

Bu oddiy sinf biz ko'rib chiqqan tamoyillarning kuchli namoyishidir. Sizni u bilan tajriba qilishga undayman. Turli xil to'lqin shakllarini sinab ko'ring, ADSR parametrlarini o'zgartiring va tovushni qanchalik tubdan o'zgartirishingiz mumkinligini ko'rish uchun filtr kesish nuqtasini o'zgartiring.

Asoslardan Tashqari: Keyingi Qadamlar

Biz audio sintez va DSPning chuqur va qiziqarli sohasining faqat yuzasiga tegindik. Agar bu sizning qiziqishingizni uyg'otgan bo'lsa, o'rganish uchun ba'zi ilg'or mavzular:

• To'lqinli Jadval Sintezi (Wavetable Synthesis): Matematik jihatdan mukammal shakllardan foydalanish o'rniga, bu usul ossillyator manbai sifatida oldindan yozib olingan, bir siklli to'lqin shakllaridan foydalanadi, bu esa nihoyatda murakkab va rivojlanuvchi tembrlarga imkon beradi.
• Granulyar Sintez: Mavjud audio namunani mayda bo'laklarga (donachalarga) ajratib, so'ngra ularni qayta tartiblash, cho'zish va ohangini o'zgartirish orqali yangi tovushlar yaratadi. Bu atmosfera teksturalari va padlarni yaratish uchun ajoyib.
• Jismoniy Modellashtirish Sintezi: Tovushni asbobning jismoniy xususiyatlarini - gitara tori, klarnet trubkasi, baraban membranasini matematik modellashtirish orqali yaratishga harakat qiladigan qiziqarli yondashuv.
• Haqiqiy Vaqtda Audioga Ishlov Berish: PyAudio va SoundCard kabi kutubxonalar sizga mikrofonlar yoki boshqa manbalardan keladigan audio oqimlari bilan real vaqtda ishlash imkonini beradi, bu esa jonli effektlar, interaktiv installyatsiyalar va boshqalarga yo'l ochadi.
• Audioda Mashinaviy Ta'lim: Sun'iy intellekt va chuqur o'rganish audioni inqilob qilmoqda. Modellar yangi musiqa yaratishi, realistik inson nutqini sintez qilishi yoki hatto aralash qo'shiqdan alohida asboblarni ajratib olishi mumkin.

Xulosa

Biz raqamli tovushning asosiy tabiatidan boshlab, funksional sintezator yaratishgacha bo'lgan yo'lni bosib o'tdik. Biz Python, NumPy va SciPy yordamida sof va murakkab to'lqin shakllarini yaratishni o'rgandik. Biz tovushlarimizga ADSR qobiqlari yordamida hayot va shakl berishni, ularning xarakterini raqamli filtrlar bilan shakllantirishni va modulyatsiya bilan dinamik harakat qo'shishni kashf etdik. Biz yozgan kod shunchaki texnik mashq emas; bu ijodiy vositadir.

Pythonning kuchli ilmiy to'plami uni audio dunyosida o'rganish, tajriba qilish va yaratish uchun ajoyib platformaga aylantiradi. Maqsadingiz loyiha uchun maxsus ovoz effektini yaratish, musiqa asbobi yasash yoki shunchaki har kuni eshitadigan tovushlar ortidagi texnologiyani tushunish bo'ladimi, bu yerda o'rgangan tamoyillaringiz sizning boshlang'ich nuqtangizdir. Endi tajriba qilish navbati sizniki. Ushbu usullarni birlashtirishni boshlang, yangi parametrlarni sinab ko'ring va natijalarni diqqat bilan tinglang. Keng tovush olami endi sizning qo'lingizda - siz nima yaratasiz?